Collaborative rendering over peer-to-peer networks

Physically-based high-fidelity rendering pervades areas like engineering, architecture, archaeology and defence, amongs others. The computationally intensive algorithms required for such visualisation benefit greatly from added computational resources when exploiting parallelism. In scenarios where multiple users roam around the same virtual scene, and possibly interact with one another, complex visualisation of phenomena like global illumination are traditionally computed and duplicated at each and every client, or centralised and computed at a single very powerful server. In this paper, we introduce the concept of collaborative high-fidelity rendering over peer-to-peer networks, which aims to reduce redundant computation via collaboration in an environment where client machines are volatile and may join or leave the network at any time.peer-reviewe

Search based software engineering

Consider the following questions, which are posed by software engineers on a daily basis: 1. What is the smallest set of test cases that will cover all statements in this program? 2. What is the best way to organise classes and methods for this OO design? 3. What is the set of requirements that balances software development cost and customer satisfaction? Whilst these questions seem to be addressing different problems, they do have some notable commonalities. Firstly, they form part of a large set of soft- ware engineering problems which can each be solved by a multitude of potential solutions. That is to say that if one were to ask the above questions to x equally competent engineers, one would likely get back x different yet correct solutions. Secondly, this class of problems is usually tasked with balancing a number of competing constraints. A typical example here is maximising customer satisfaction whilst keeping development costs low. Finally, whilst there is typically no perfect answer (and indeed no precise rules for computing the best solution), good solutions can be recognised. When problems with similar characteristics were encountered in disciplines other than software engineering, they were solved with a large degree of success using search-based techniques. It was this realisation that gave rise to the field of search based software engineering.peer-reviewe

Point-cloud decomposition for scene analysis and understanding

Over the past decade digital photography has taken over traditional film based photography. The same can be said for video productions. A practice traditionally reserved only for the few has nowadays become commonplace. This has led to the creation of massive repositories of digital photographs and videos in various formats. Recently, another digital representation has started picking up, namely one that captures the geometry of real-world objects. In the latter, instead of using light sensors to store per pixel colour values of visible objects, depth sensors (and additional hardware) are used to record the distance (depth) to the visible objects in a scene. This depth information can be used to create virtual reconstructions of the objects and scenes captured. Various technologies have been proposed and successfully used to acquire this information, ranging from very expensive equipment (e.g. long range 3D scanners) to commodity hard- ware (e.g. Microsoft Kinect and Asus Xtion). A considerable amount of research has also looked into the extraction of accurate depth information from multi- view photographs of objects using specialised software (e.g. Microsoft Photo- Synth amongst many others). Recently, rapid advances in ubiqutous computing, has also brought to the masses the possibility of capturing the world around them in 3D using smartphones and tablets (e.g. http://structure.io/).peer-reviewe

Detecting web server take-over attacks through objective verification actions

Attacks targeting web servers pose a major security threat. Typically prone to a mix of infrastructure and application-level security vulnerabilities, they serve as the lowest hanging fruit for intruders wanting to gain unauthorized access to the entire host network. This is specifically the case for ‘server take- over’ attacks, whose immediate objective is to gain unauthorized remote access to the host server, for example through shell-spawning, backdooring or botnet joining.peer-reviewe

Synthesising implicit contracts

In regulated interactive systems, one party’s behaviour may impose restrictions on how others may behave when interacting with it. These restrictions may be seen as implicit contracts which the affected party has to conform to and may thus be considered inappropriate or excessive if they overregulate one of the parties. In, we have characterised such implicit contracts and present an algorithmic way of synthesising them using a formalism based on contract automata to regulate interactive action-based systems. In this presentation, we outline the problem and future extensions of the work we are currently exploring.peer-reviewe

Equivalence proofs for Erlang refactoring

Erlang is an actor-based programming language used extensively for building concurrent, reactive systems that are highlighly available and suffer minimum downtime. Such systems are often mission critical, making system correctness vital. In industrial-scale systems, correctness is usually ascertained through testing, a lightweight verification technique trading analysis completeness for scalability. In such cases, a system is deemed correct whenever it “passes” a suite of tests, each checking for the correct functionality of a particular aspect of a system. This is also true for large Erlang systems: even when correctness specifications are provided, it is commonplace for Erlang developers to use testing tools, automating test-case generation from these specifications.peer-reviewe

Using symbolic execution for equivalent mutant detection

Mutation Testing is a fault injection technique used to measure test adequacy score by generating defects (mutations) in a program and checking if its test suite is able to detect such a change. However, this technique suffers from the Equivalent Mutant Problem. Equivalent mutants are mutants which on mutation retain their semantics. Thus, although equivalent mutants are syntactically different, they remain semantically equivalent to the original program. An automated solution which decides equivalence is impossible, as equivalence of non-trivial programs is undecidable. The fact that the Equivalent Mutant Problem is undecidable usually means that human effort is required to decide equivalence. Equivalent mutants are the barrier keeping Mutation Testing from being widely adopted. Moreover, in one study by Irvine et al, the average time taken for each manual mutant classification was fifteen minutes.peer-reviewe

Applying runtime verification techniques to enterprise service bus architectures

The increased usage of distributed systems has led to the problem of integration of IT systems that communicate via different protocols. In such setting, it is also typical for these components to be added/removed from the system at runtime, depending on requirements. These two characteristics give rise to integration challenges where systems should be able to communicate seamlessly with each other whilst being able to be easily integrated with an existing distributed system with minimal impact. An ESB (Enterprise Service Bus) is a tool which attempts to address the above issues by integrating systems in a bus-like architecture where a central bus enables components to communicate via messages. This arrangement, transparently handling complex messaging functions such as transformation and routing (via routing patterns), enables the user to focus on the business logic, abstracting away communication concerns [6]. Despite facilitating orchestration of distributed components in a scalable manner, current ESBs provide little support for correctness guarantees of the overall system logic e.g. a booking component may only confirm the booking once the bank component has verified the payment details, and the airline component confirms that the dates specified are permissible. Popular techniques for ensuring correctness, such as testing and model checking are not ideal for verifying the correctness of ESB systems due to the latter’s highly dynamic nature. For this reason, we propose to apply runtime verification techniques, promising a scalable approach to checking all observed behaviour under any runtime circumstance — no matter how unpredictable this may be.peer-reviewe

Leveraging P2P systems to address the test scenario explosion problem

Modern software development is characterised by a strong customer focus and electronic delivery mechanisms which make it very easy for customers to buy and install a vendor’s software. However, it also makes it very easy for customers to buy and install software from competing vendors and as such it is more important than ever for deployed software to be as correct and bug-free as possible. Whilst certain types of testing can be done in the lab with a high degree of confidence that results will hold when the software is deployed in the wild, in reality software systems are subject to influence from whatever environment they end up being deployed in. Varying factors in customer environments can include operating systems, services packs, device drivers, network connectivity, resource usage by other software, and so on. Any variation or combination of these factors can lead to a situation where a system deviates from its expected behaviour. The problem is amplified even further on mobile devices whereby devices can move between different networks, interrupt apps for phone calls, have varying screen sizes, have user interference in the form of turning features on and o↵ to preserve battery power, vendor-specific operating system code, and so on. A conservative calculation indicates that a software system can be subjected to tens of thousands of different scenarios. Even if one were to execute just one test case against each scenario, obtaining any form of realistic coverage is infeasible for even the most resource-rich organisations. Cloud and grid infrastructures have been proposed as solutions to improving the scalability of software testing since 2008. However, we argue that cloud computing systems are too homogenous and are not representative of real-world usage scenarios. We refer to this problem as the Test Scenario Explosion Problem.peer-reviewe

Towards an abstraction for remote evaluation in Erlang

Erlang is an industry-standard cross-platform functional programming language and runtime system (ERTS) intended for the development of concurrent and distributed systems. An Erlang system consists of a number of actors [3] (processes) executing concurrently across a number of nodes. These actors interact with one another (mainly) through asynchronous messaging and are also capable of spawning further actors, either locally or at a remote node.peer-reviewe